.TH std::is_signed 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::is_signed \- std::is_signed

.SH Synopsis
   Defined in header <type_traits>
   template< class T >              \fI(since C++11)\fP
   struct is_signed;

   std::is_signed is a UnaryTypeTrait.

   If T is an arithmetic type, provides the member constant value equal to true if
   T(-1) < T\fB(0)\fP: this results in true for the floating-point types and the signed
   integer types, and in false for the unsigned integer types and the type bool.

   For any other type, value is false.

   If the program adds specializations for std::is_signed or std::is_signed_v, the
   behavior is undefined.

.SH Template parameters

   T - a type to check

   Helper variable template

   template< class T >                                       \fI(since C++17)\fP
   inline constexpr bool is_signed_v = is_signed<T>::value;



Inherited from std::integral_constant

.SH Member constants

   value    true if T is a signed arithmetic type, false otherwise
   \fB[static]\fP \fI(public static member constant)\fP

.SH Member functions

   operator bool converts the object to bool, returns value
                 \fI(public member function)\fP
   operator()    returns value
   \fI(C++14)\fP       \fI(public member function)\fP

.SH Member types

   Type       Definition
   value_type bool
   type       std::integral_constant<bool, value>

.SH Possible implementation

   namespace detail
   {
       template<typename T, bool = std::is_arithmetic<T>::value>
       struct is_signed : std::integral_constant<bool, T(-1) < T\fB(0)\fP> {};

       template<typename T>
       struct is_signed<T, false> : std::false_type {};
   }

   template<typename T>
   struct is_signed : detail::is_signed<T>::type {};

.SH Example


// Run this code

 #include <iostream>
 #include <type_traits>

 class A {};
 static_assert(std::is_signed_v<A> == false);

 class B { int i; };
 static_assert(std::is_signed_v<B> == false);

 enum C : int {};
 static_assert(std::is_signed_v<C> == false);

 enum class D : int {};
 static_assert(std::is_signed_v<D> == false);

 static_assert(
     std::is_signed<signed int>::value == true and // C++11
     std::is_signed<signed int>() == true and      // C++11
     std::is_signed<signed int>{} == true and      // C++11
     std::is_signed_v<signed int> == true and      // C++17
     std::is_signed_v<unsigned int> == false and
     std::is_signed_v<float> == true and
     std::is_signed_v<bool> == false and
     std::is_signed_v<signed char> == true and
     std::is_signed_v<unsigned char> == false
 );

 int main()
 {
     // signedness of char is implementation-defined:
     std::cout << std::boolalpha << std::is_signed_v<char> << '\\n';
 }

.SH Possible output:

 true

.SH See also

   is_unsigned   checks if a type is an unsigned arithmetic type
   \fI(C++11)\fP       \fI(class template)\fP
   is_signed     identifies signed types
   \fB[static]\fP      \fI(public static member constant of std::numeric_limits<T>)\fP
   is_arithmetic checks if a type is an arithmetic type
   \fI(C++11)\fP       \fI(class template)\fP
   make_signed   makes the given integral type signed
   \fI(C++11)\fP       \fI(class template)\fP
   make_unsigned makes the given integral type unsigned
   \fI(C++11)\fP       \fI(class template)\fP
